juce/source/extras/the jucer/src/model/components/jucer_ImageButtonHandler.h

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #ifndef __JUCER_IMAGEBUTTONHANDLER_JUCEHEADER__
  27 #define __JUCER_IMAGEBUTTONHANDLER_JUCEHEADER__
  28
  29 #include "jucer_ButtonHandler.h"
  30 #include "../../properties/jucer_ComponentColourProperty.h"
  31 #include "../paintelements/jucer_ImageResourceProperty.h"
  32
  33
  34 //==============================================================================
  35 /**
  36 */
  37 class ImageButtonHandler  : public ButtonHandler
  38 {
  39 public:
  40     enum ImageRole
  41     {
  42         normalImage = 0,
  43         overImage = 1,
  44         downImage = 2
  45     };
  46
  47     //==============================================================================
  48     ImageButtonHandler()
  49         : ButtonHandler ("Image Button", "ImageButton", typeid (ImageButton), 150, 24)
  50     {
  51     }
  52
  53     //==============================================================================
  54     Component* createNewComponent (JucerDocument*)
  55     {
  56         return new ImageButton ("new button");
  57     }
  58
  59     void getEditableProperties (Component* component, JucerDocument& document, Array <PropertyComponent*>& properties)
  60     {
  61         ButtonHandler::getEditableProperties (component, document, properties);
  62
  63         addColourProperties (component, document, properties);
  64
  65         ImageButton* const ib = (ImageButton*) component;
  66
  67         ComponentLayout& layout = *document.getComponentLayout();
  68
  69         properties.add (new ImageButtonProportionProperty (layout, ib));
  70
  71         properties.add (new ImageButtonResourceProperty (layout, ib, normalImage, "normal image"));
  72         properties.add (new ImageButtonOpacityProperty (layout, ib, "opacity", normalImage));
  73         properties.add (new ImageButtonColourProperty (layout, ib, "overlay col.", normalImage));
  74
  75         properties.add (new ImageButtonResourceProperty (layout, ib, overImage, "over image"));
  76         properties.add (new ImageButtonOpacityProperty (layout, ib, "opacity", overImage));
  77         properties.add (new ImageButtonColourProperty (layout, ib, "overlay col.", overImage));
  78
  79         properties.add (new ImageButtonResourceProperty (layout, ib, downImage, "down image"));
  80         properties.add (new ImageButtonOpacityProperty (layout, ib, "opacity", downImage));
  81         properties.add (new ImageButtonColourProperty (layout, ib, "overlay col.", downImage));
  82     }
  83
  84     XmlElement* createXmlFor (Component* comp, const ComponentLayout* layout)
  85     {
  86         XmlElement* e = ButtonHandler::createXmlFor (comp, layout);
  87
  88         ImageButton* const ib = (ImageButton*) comp;
  89
  90         e->setAttribute ("keepProportions", doesImageKeepProportions (ib));
  91
  92         e->setAttribute ("resourceNormal", getImageResource (ib, normalImage));
  93         e->setAttribute ("opacityNormal", getImageOpacity (ib, normalImage));
  94         e->setAttribute ("colourNormal", getImageColour (ib, normalImage).toString());
  95
  96         e->setAttribute ("resourceOver", getImageResource (ib, overImage));
  97         e->setAttribute ("opacityOver", getImageOpacity (ib, overImage));
  98         e->setAttribute ("colourOver", getImageColour (ib, overImage).toString());
  99
 100         e->setAttribute ("resourceDown", getImageResource (ib, downImage));
 101         e->setAttribute ("opacityDown", getImageOpacity (ib, downImage));
 102         e->setAttribute ("colourDown", getImageColour (ib, downImage).toString());
 103
 104         return e;
 105     }
 106
 107     bool restoreFromXml (const XmlElement& xml, Component* comp, const ComponentLayout* layout)
 108     {
 109         if (! ButtonHandler::restoreFromXml (xml, comp, layout))
 110             return false;
 111
 112         ImageButton* const ib = (ImageButton*) comp;
 113         ComponentLayout& l = const_cast <ComponentLayout&> (*layout);
 114
 115         setImageKeepProportions (l, ib, xml.getBoolAttribute ("keepProportions", true), false);
 116
 117         setImageResource (l, ib, normalImage, xml.getStringAttribute ("resourceNormal", String::empty), false);
 118         setImageOpacity (l, ib, normalImage, (float) xml.getDoubleAttribute ("opacityNormal", 1.0f), false);
 119         setImageColour (l, ib, normalImage, Colour::fromString (xml.getStringAttribute ("colourNormal", "0")), false);
 120
 121         setImageResource (l, ib, overImage, xml.getStringAttribute ("resourceOver", String::empty), false);
 122         setImageOpacity (l, ib, overImage, (float) xml.getDoubleAttribute ("opacityOver", 1.0f), false);
 123         setImageColour (l, ib, overImage, Colour::fromString (xml.getStringAttribute ("colourOver", "0")), false);
 124
 125         setImageResource (l, ib, downImage, xml.getStringAttribute ("resourceDown", String::empty), false);
 126         setImageOpacity (l, ib, downImage, (float) xml.getDoubleAttribute ("opacityDown", 1.0f), false);
 127         setImageColour (l, ib, downImage, Colour::fromString (xml.getStringAttribute ("colourDown", "0")), false);
 128
 129         return true;
 130     }
 131
 132     void fillInCreationCode (GeneratedCode& code, Component* component, const String& memberVariableName)
 133     {
 134         ButtonHandler::fillInCreationCode (code, component, memberVariableName);
 135
 136         ImageButton* const ib = dynamic_cast <ImageButton*> (component);
 137
 138         String s;
 139
 140         s << getColourIntialisationCode (component, memberVariableName)
 141           << '\n';
 142
 143         const String indent (String::repeatedString (" ", memberVariableName.length() + 13));
 144
 145         s << memberVariableName << "->setImages (false, true, "
 146           << boolToString (doesImageKeepProportions (ib)) << ",\n"
 147           << indent
 148           << getImageCreationCode (ib, normalImage) << ", "
 149           << valueToFloat (getImageOpacity (ib, normalImage)) << ", "
 150           << colourToCode (getImageColour (ib, normalImage)) << ",\n"
 151           << indent
 152           << getImageCreationCode (ib, overImage) << ", "
 153           << valueToFloat (getImageOpacity (ib, overImage)) << ", "
 154           << colourToCode (getImageColour (ib, overImage)) << ",\n"
 155           << indent
 156           << getImageCreationCode (ib, downImage) << ", "
 157           << valueToFloat (getImageOpacity (ib, downImage)) << ", "
 158           << colourToCode (getImageColour (ib, downImage))
 159           << ");\n";
 160
 161         code.constructorCode += s;
 162     }
 163
 164     static const String getImageCreationCode (ImageButton* ib, const ImageRole role)
 165     {
 166         const String resName (getImageResource (ib, role));
 167
 168         if (resName.isEmpty())
 169             return "Image()";
 170
 171         return "ImageCache::getFromMemory (" + resName + ", " + resName + "Size)";
 172     }
 173
 174     //==============================================================================
 175     class ImageButtonResourceProperty    : public ImageResourceProperty <ImageButton>
 176     {
 177     public:
 178         ImageButtonResourceProperty (ComponentLayout& layout_, ImageButton* const owner_, const ImageRole role_, const String& name)
 179             : ImageResourceProperty <ImageButton> (*layout_.getDocument(), owner_, name, true),
 180               role (role_),
 181               layout (layout_)
 182         {
 183         }
 184
 185         //==============================================================================
 186         void setResource (const String& newName)
 187         {
 188             setImageResource (layout, element, role, newName, true);
 189         }
 190
 191         const String getResource() const
 192         {
 193             return getImageResource (element, role);
 194         }
 195
 196     private:
 197         const ImageRole role;
 198         ComponentLayout& layout;
 199     };
 200
 201     class SetImageResourceAction   : public ComponentUndoableAction <ImageButton>
 202     {
 203     public:
 204         SetImageResourceAction (ImageButton* const button,
 205                                 ComponentLayout& layout_,
 206                                 const ImageRole role_,
 207                                 const String& newResource_)
 208             : ComponentUndoableAction <ImageButton> (button, layout_),
 209               newResource (newResource_),
 210               role (role_),
 211               layout (layout_)
 212         {
 213             oldResource = ImageButtonHandler::getImageResource (button, role_);
 214         }
 215
 216         bool perform()
 217         {
 218             showCorrectTab();
 219             ImageButtonHandler::setImageResource (layout, getComponent(), role, newResource, false);
 220             return true;
 221         }
 222
 223         bool undo()
 224         {
 225             showCorrectTab();
 226             ImageButtonHandler::setImageResource (layout, getComponent(), role, oldResource, false);
 227             return true;
 228         }
 229
 230     private:
 231         String newResource, oldResource;
 232         const ImageRole role;
 233         ComponentLayout& layout;
 234     };
 235
 236     //==============================================================================
 237     static void setImageResource (ComponentLayout& layout, ImageButton* button, const ImageRole role, const String& newName, const bool undoable)
 238     {
 239         jassert (role < 3);
 240
 241         if (role < 3 && getImageResource (button, role) != newName)
 242         {
 243             if (undoable)
 244             {
 245                 layout.getDocument()->perform (new SetImageResourceAction (button, layout, role, newName),
 246                                                "Change image resource");
 247             }
 248             else
 249             {
 250                 button->getProperties().set ("resource" + String ((int) role), newName);
 251                 updateButtonImages (*layout.getDocument(), button);
 252                 layout.changed();
 253             }
 254         }
 255     }
 256
 257     static const String getImageResource (ImageButton* button, const ImageRole role)
 258     {
 259         jassert (role < 3);
 260         return button->getProperties() ["resource" + String ((int) role)].toString();
 261     }
 262
 263     //==============================================================================
 264     class SetImageKeepsPropAction   : public ComponentUndoableAction <ImageButton>
 265     {
 266     public:
 267         SetImageKeepsPropAction (ImageButton* const button,
 268                                  ComponentLayout& layout_,
 269                                  const bool newState_)
 270             : ComponentUndoableAction <ImageButton> (button, layout_),
 271               layout (layout_),
 272               newState (newState_)
 273         {
 274             oldState = ImageButtonHandler::doesImageKeepProportions (button);
 275         }
 276
 277         bool perform()
 278         {
 279             showCorrectTab();
 280             ImageButtonHandler::setImageKeepProportions (layout, getComponent(), newState, false);
 281             return true;
 282         }
 283
 284         bool undo()
 285         {
 286             showCorrectTab();
 287             ImageButtonHandler::setImageKeepProportions (layout, getComponent(), oldState, false);
 288             return true;
 289         }
 290
 291     private:
 292         bool newState, oldState;
 293         ComponentLayout& layout;
 294     };
 295
 296     static bool doesImageKeepProportions (ImageButton* button)
 297     {
 298         return button->getProperties().getWithDefault ("keepImageProp", true);
 299     }
 300
 301     static void setImageKeepProportions (ComponentLayout& layout, ImageButton* button, const bool newState, const bool undoable)
 302     {
 303         if (undoable)
 304         {
 305             layout.perform (new SetImageKeepsPropAction (button, layout, newState), "change imagebutton proportion mode");
 306         }
 307         else
 308         {
 309             button->getProperties().set ("keepImageProp", newState);
 310             updateButtonImages (*layout.getDocument(), button);
 311             layout.changed();
 312         }
 313     }
 314
 315     class ImageButtonProportionProperty    : public ComponentBooleanProperty <ImageButton>
 316     {
 317     public:
 318         ImageButtonProportionProperty (ComponentLayout& layout_, ImageButton* const owner_)
 319             : ComponentBooleanProperty <ImageButton> ("proportional", "maintain image proportions", "scale to fit",
 320                                                       owner_, *layout_.getDocument()),
 321               layout (layout_)
 322         {
 323         }
 324
 325         //==============================================================================
 326         void setState (bool newState)
 327         {
 328             setImageKeepProportions (layout, component, newState, true);
 329         }
 330
 331         bool getState() const
 332         {
 333             return doesImageKeepProportions (component);
 334         }
 335
 336     private:
 337         ComponentLayout& layout;
 338     };
 339
 340     //==============================================================================
 341     class SetImageOpacityAction   : public ComponentUndoableAction <ImageButton>
 342     {
 343     public:
 344         SetImageOpacityAction (ImageButton* const button,
 345                                ComponentLayout& layout_,
 346                                const ImageRole role_,
 347                                const float newState_)
 348             : ComponentUndoableAction <ImageButton> (button, layout_),
 349               role (role_),
 350               layout (layout_),
 351               newState (newState_)
 352         {
 353             oldState = ImageButtonHandler::getImageOpacity (button, role_);
 354         }
 355
 356         bool perform()
 357         {
 358             showCorrectTab();
 359             ImageButtonHandler::setImageOpacity (layout, getComponent(), role, newState, false);
 360             return true;
 361         }
 362
 363         bool undo()
 364         {
 365             showCorrectTab();
 366             ImageButtonHandler::setImageOpacity (layout, getComponent(), role, oldState, false);
 367             return true;
 368         }
 369
 370     private:
 371         const ImageRole role;
 372         float newState, oldState;
 373         ComponentLayout& layout;
 374     };
 375
 376     static float getImageOpacity (ImageButton* button, const ImageRole role)
 377     {
 378         return (float) button->getProperties().getWithDefault ("imageOpacity" + String ((int) role), 1.0f);
 379     }
 380
 381     static void setImageOpacity (ComponentLayout& layout, ImageButton* button, const ImageRole role, const float opacity, const bool undoable)
 382     {
 383         if (undoable)
 384         {
 385             layout.perform (new SetImageOpacityAction (button, layout, role, opacity), "change imagebutton opacity");
 386         }
 387         else
 388         {
 389             button->getProperties().set ("imageOpacity" + String ((int) role), opacity);
 390             updateButtonImages (*layout.getDocument(), button);
 391             layout.changed();
 392         }
 393     }
 394
 395     class ImageButtonOpacityProperty    : public SliderPropertyComponent
 396     {
 397     public:
 398         ImageButtonOpacityProperty (ComponentLayout& layout_, ImageButton* const owner_,
 399                                     const String& name, const ImageRole role_)
 400             : SliderPropertyComponent (name, 0.0, 1.0, 0.0),
 401               owner (owner_),
 402               layout (layout_),
 403               role (role_)
 404         {
 405         }
 406
 407         //==============================================================================
 408         void setValue (double newValue)
 409         {
 410             setImageOpacity (layout, owner, role, (float) newValue, true);
 411         }
 412
 413         double getValue() const
 414         {
 415             return getImageOpacity (owner, role);
 416         }
 417
 418     private:
 419         ImageButton* const owner;
 420         ComponentLayout& layout;
 421         const ImageRole role;
 422     };
 423
 424     //==============================================================================
 425     class SetImageColourAction   : public ComponentUndoableAction <ImageButton>
 426     {
 427     public:
 428         SetImageColourAction (ImageButton* const button,
 429                               ComponentLayout& layout_,
 430                               const ImageRole role_,
 431                               const Colour& newState_)
 432             : ComponentUndoableAction <ImageButton> (button, layout_),
 433               role (role_),
 434               layout (layout_),
 435               newState (newState_)
 436         {
 437             oldState = ImageButtonHandler::getImageColour (button, role_);
 438         }
 439
 440         bool perform()
 441         {
 442             showCorrectTab();
 443             ImageButtonHandler::setImageColour (layout, getComponent(), role, newState, false);
 444             return true;
 445         }
 446
 447         bool undo()
 448         {
 449             showCorrectTab();
 450             ImageButtonHandler::setImageColour (layout, getComponent(), role, oldState, false);
 451             return true;
 452         }
 453
 454     private:
 455         const ImageRole role;
 456         Colour newState, oldState;
 457         ComponentLayout& layout;
 458     };
 459
 460     static const Colour getImageColour (ImageButton* button, const ImageRole role)
 461     {
 462         return Colour::fromString (button->getProperties().getWithDefault ("imageColour" + String ((int) role), "0").toString());
 463     }
 464
 465     static void setImageColour (ComponentLayout& layout, ImageButton* button, const ImageRole role, const Colour& colour, const bool undoable)
 466     {
 467         if (undoable)
 468         {
 469             layout.perform (new SetImageColourAction (button, layout, role, colour), "change imagebutton colour");
 470         }
 471         else
 472         {
 473             button->getProperties().set ("imageColour" + String ((int) role), colour.toString());
 474             updateButtonImages (*layout.getDocument(), button);
 475             layout.changed();
 476         }
 477     }
 478
 479     class ImageButtonColourProperty    : public ColourPropertyComponent,
 480                                          public ChangeListener
 481     {
 482     public:
 483         ImageButtonColourProperty (ComponentLayout& layout_, ImageButton* const owner_,
 484                                    const String& name, const ImageRole role_)
 485             : ColourPropertyComponent (name, false),
 486               owner (owner_),
 487               layout (layout_),
 488               role (role_)
 489         {
 490             layout_.getDocument()->addChangeListener (this);
 491         }
 492
 493         ~ImageButtonColourProperty()
 494         {
 495             layout.getDocument()->removeChangeListener (this);
 496         }
 497
 498         //==============================================================================
 499         void setColour (const Colour& newColour)
 500         {
 501             setImageColour (layout, owner, role, newColour, true);
 502         }
 503
 504         const Colour getColour() const
 505         {
 506             return getImageColour (owner, role);
 507         }
 508
 509         void resetToDefault() {}
 510
 511         void changeListenerCallback (ChangeBroadcaster*)
 512         {
 513             refresh();
 514         }
 515
 516     private:
 517         ImageButton* const owner;
 518         ComponentLayout& layout;
 519         const ImageRole role;
 520     };
 521
 522     //==============================================================================
 523     static void updateButtonImages (JucerDocument& document, ImageButton* const ib)
 524     {
 525         Image norm = document.getResources().getImageFromCache (getImageResource (ib, normalImage));
 526         Image over = document.getResources().getImageFromCache (getImageResource (ib, overImage));
 527         Image down = document.getResources().getImageFromCache (getImageResource (ib, downImage));
 528
 529         ib->setImages (false, true, doesImageKeepProportions (ib),
 530                        norm,
 531                        getImageOpacity (ib, normalImage),
 532                        getImageColour (ib, normalImage),
 533                        over,
 534                        getImageOpacity (ib, overImage),
 535                        getImageColour (ib, overImage),
 536                        down,
 537                        getImageOpacity (ib, downImage),
 538                        getImageColour (ib, downImage));
 539     }
 540 };
 541
 542
 543 #endif   // __JUCER_IMAGEBUTTONHANDLER_JUCEHEADER__